use nacos_cluster::manager::{ClusterManager, ClusterConfig};
use nacos_cluster::node::ClusterNodeInfo;
use std::sync::Arc;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> nacos_core::Result<()> {
    println!("🏛️ 集群选举故障测试演示");
    println!("================================");
    
    // 创建3个节点的集群配置
    let configs = vec![
        ClusterConfig {
            cluster_name: "test-cluster".to_string(),
            heartbeat_timeout: 5,  // 5秒心跳超时
            election_timeout: 1000, // 1秒选举超时
            current_node_id: "node1".to_string(),
            initial_nodes: vec!["node1:8848".to_string(), "node2:8849".to_string(), "node3:8850".to_string()],
        },
        ClusterConfig {
            cluster_name: "test-cluster".to_string(),
            heartbeat_timeout: 5,
            election_timeout: 1000,
            current_node_id: "node2".to_string(),
            initial_nodes: vec!["node1:8848".to_string(), "node2:8849".to_string(), "node3:8850".to_string()],
        },
        ClusterConfig {
            cluster_name: "test-cluster".to_string(),
            heartbeat_timeout: 5,
            election_timeout: 1000,
            current_node_id: "node3".to_string(),
            initial_nodes: vec!["node1:8848".to_string(), "node2:8849".to_string(), "node3:8850".to_string()],
        },
    ];
    
    // 创建集群管理器
    let managers: Vec<Arc<ClusterManager>> = configs
        .into_iter()
        .map(|config| Arc::new(ClusterManager::new(config)))
        .collect();
    
    // 初始化节点
    let nodes = vec![
        ClusterNodeInfo::new("127.0.0.1", 8848, 3), // 权重最高，作为主节点
        ClusterNodeInfo::new("127.0.0.1", 8849, 2),
        ClusterNodeInfo::new("127.0.0.1", 8850, 1),
    ];
    
    println!("📊 初始化集群节点:");
    for (i, node) in nodes.iter().enumerate() {
        println!("   🖥️  {}: {} (权重: {})", 
            managers[i].config.current_node_id, node.address, node.weight);
    }
    
    // 启动所有节点
    println!("\n🚀 启动集群...");
    for (i, manager) in managers.iter().enumerate() {
        manager.initialize(nodes[i].clone()).await?;
        println!("   ✅ {} 启动完成", manager.config.current_node_id);
    }
    
    // 等待集群稳定
    sleep(Duration::from_secs(2)).await;
    
    // 显示初始主节点
    let initial_leader = managers[0].get_current_leader().await;
    println!("\n👑 初始主节点: {}", 
        initial_leader.as_ref().map(|n| n.id.as_str()).unwrap_or("选举中"));
    
    // 模拟主节点故障
    println!("\n⚡ 模拟主节点故障 (node1)...");
    managers[0].mark_node_failed("node1").await?;
    
    // 等待新主节点选举
    println!("⏳ 等待新主节点选举...");
    sleep(Duration::from_secs(3)).await;
    
    // 检查新主节点
    let new_leader = managers[1].get_current_leader().await;
    println!("👑 新主节点: {}", 
        new_leader.as_ref().map(|n| n.id.as_str()).unwrap_or("选举中"));
    
    // 验证集群状态
    println!("\n📊 集群状态验证:");
    for manager in &managers {
        let status = manager.get_cluster_status().await?;
        println!("   {}: {} ({} 个节点)", 
            manager.config.current_node_id, 
            status.state, 
            status.total_nodes);
    }
    
    // 测试故障恢复
    println!("\n🔄 模拟故障节点恢复...");
    managers[0].mark_node_recovered("node1").await?;
    
    sleep(Duration::from_secs(2)).await;
    
    // 最终状态
    let final_leader = managers[2].get_current_leader().await;
    println!("👑 最终主节点: {}", 
        final_leader.as_ref().map(|n| n.id.as_str()).unwrap_or("选举中"));
    
    // 清理
    for manager in &managers {
        manager.shutdown().await?;
    }
    
    println!("\n🎯 集群选举测试完成！");
    println!("📈 测试总结:");
    println!("   ✅ 集群初始化成功");
    println!("   ✅ 主节点故障检测成功");
    println!("   ✅ 新主节点选举成功");
    println!("   ✅ 故障节点恢复成功");
    println!("   ✅ 集群高可用性验证完成");
    
    Ok(())
}